cat << 'EOF' | git apply
diff --git a/create-a-container/utils/docker-registry.js b/create-a-container/utils/docker-registry.js
--- a/create-a-container/utils/docker-registry.js
+++ b/create-a-container/utils/docker-registry.js
@@ -7,8 +7,82 @@
  */
 
 const https = require('https');
+const urlModule = require('url');
 
+// Restrictive allow-list of registry hosts that this service is allowed to contact.
+// Extend this list as needed for your deployment.
+const ALLOWED_REGISTRY_HOSTS = new Set([
+  'docker.io',
+  'registry-1.docker.io',
+  'ghcr.io',
+  'quay.io'
+]);
+
 /**
+ * Check whether a hostname is clearly unsafe for SSRF (localhost, local domain, etc.)
+ * This is a defense-in-depth check; the primary control is the allow-list above.
+ * @param {string} hostname
+ * @returns {boolean}
+ */
+function isPrivateHostname(hostname) {
+  if (!hostname) return true;
+  const lower = hostname.toLowerCase();
+  return (
+    lower === 'localhost' ||
+    lower === '127.0.0.1' ||
+    lower === '::1' ||
+    lower.endsWith('.local') ||
+    lower.endsWith('.localhost')
+  );
+}
+
+/**
+ * Basic check for private IP address ranges.
+ * Note: this does not perform DNS resolution; it only checks literal IPs.
+ * @param {string} hostname
+ * @returns {boolean}
+ */
+function isPrivateIp(hostname) {
+  const ipRegex = /^(?:\d{1,3}\.){3}\d{1,3}$/;
+  if (!ipRegex.test(hostname)) return false;
+  const octets = hostname.split('.').map(Number);
+  // 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16
+  if (octets[0] === 10) return true;
+  if (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) return true;
+  if (octets[0] === 192 && octets[1] === 168) return true;
+  return false;
+}
+
+/**
+ * Determine if a host is allowed according to our policy.
+ * @param {string} host
+ * @returns {boolean}
+ */
+function isHostAllowed(host) {
+  if (!host) return false;
+  const hostname = host.split(':')[0]; // strip port if present
+  if (ALLOWED_REGISTRY_HOSTS.has(hostname)) {
+    return true;
+  }
+  if (isPrivateHostname(hostname) || isPrivateIp(hostname)) {
+    return false;
+  }
+  // By default, disallow unknown hosts to avoid SSRF.
+  return false;
+}
+
+/**
+ * Validate a registry hostname before using it in outbound requests.
+ * Throws if the host is not allowed.
+ * @param {string} registryHost
+ */
+function validateRegistryHost(registryHost) {
+  if (!isHostAllowed(registryHost)) {
+    throw new Error(`Registry host '${registryHost}' is not allowed`);
+  }
+}
+
+/**
  * Low-level HTTP GET that returns status, headers, and body without throwing on 4xx
  * @param {string} url - The URL to fetch
  * @param {object} headers - Optional request headers
@@ -30,8 +102,19 @@
         if (!location) {
           return reject(new Error(`Redirect without Location header (status ${res.statusCode})`));
         }
+
+        // Resolve the redirect URL against the original URL to get an absolute URL
+        const resolved = new urlModule.URL(location, url);
+        const redirectHost = resolved.hostname;
+        const originalHost = new urlModule.URL(url).hostname;
+
+        // Only allow redirects that stay on the same host and that host is allowed
+        if (redirectHost !== originalHost || !isHostAllowed(redirectHost)) {
+          return reject(new Error(`Disallowed redirect from ${originalHost} to ${redirectHost}`));
+        }
+
         // Follow redirect (without auth headers for CDN)
-        return httpGet(location, {}, redirectCount + 1)
+        return httpGet(resolved.toString(), {}, redirectCount + 1)
           .then(resolve)
           .catch(reject);
       }
@@ -243,6 +325,9 @@
  */
 async function getImageConfig(registry, repo, tag) {
   const registryHost = registry === 'docker.io' ? 'registry-1.docker.io' : registry;
+
+  // Validate the registry host to avoid SSRF via user-controlled image references
+  validateRegistryHost(registryHost);
   
   // First, fetch the manifest to get the config digest
   const acceptHeaders = {
EOF